// src/services/user.service.js
import { db } from "../config/sequelize.js";
import { Op } from "sequelize"; // 必须引入 Op 操作符
import { NotFoundError, BadRequestError } from "../utils/errors.js";
import User from "../models/user.model.js";
import bcrypt from "bcryptjs";

class UserService {
  constructor(db) {
    this.db = db;
    this.User = db.models.User; // 假设你的模型已关联
    this.Op = db.sequelize.Op;
    // 确保包含你需要的所有字段
    this.ADMIN_ATTRIBUTES = [
      "id",
      "username",
      "nickname", // 添加
      "avatar", // 添加
      "email", // 添加
      "phone", // 添加
      "role",
      "status",
      "refresh_token",
      "createdAt",
      "updatedAt",
    ];

    this.PUBLIC_ATTRIBUTES = [
      "id",
      "username",
      "nickname", // 公开可见字段
      "avatar", // 公开可见字段
    ];
  }
  // 公共业务逻辑
   async getPublicProfile(userId) {
    console.log("getPublicProfile", userId);
    const user = await this._getUser(userId);
    return {
      id: user.id,
      name: user.name,
      avatar: user.avatar,
    };
  }

  // 管理后台专用
   async searchWithSensitiveInfo(query) {
    return db.users.findMany({
      where: query,
      select: ALL_FIELDS, // 包含敏感字段
    });
  }

  /**
   * 获取用户列表（支持分页、筛选和排序）
   * @param {Object} options - 查询选项
   * @param {Object} options.where - 筛选条件
   * @param {number} options.page - 页码（默认1）
   * @param {number} options.limit - 每页条数（默认10）
   * @param {Array} options.order - 排序规则
   * @param {boolean} options.isAdmin - 是否管理员权限
   * @returns {Promise<{data: Array, pagination: Object}>}
   */
   async getUserList({
    where = {},
    page = 1,
    limit = 10,
    order = [["createdAt", "DESC"]],
    isAdmin = false,
  }) {
    console.log("权限：", isAdmin);
    // 1. 设置返回字段
    const attributes = isAdmin ? this.ADMIN_ATTRIBUTES : this.PUBLIC_ATTRIBUTES;

    // 2. 构建查询条件
    const sanitizedWhere = this._buildWhereClause(where);

    // 3. 执行分页查询
    const { count, rows } = await this.User.findAndCountAll({
      where: sanitizedWhere,
      attributes,
      order,
      limit: Number(limit),
      offset: (page - 1) * limit,
      paranoid: true, // 不包含软删除的记录
    });
    return {
      data: rows,
      pagination: {
        total: count,
        page: Number(page),
        limit: Number(limit),
        totalPages: Math.ceil(count / limit),
      },
    };
  }

  /**
   * 构建安全的WHERE条件（防止SQL注入）
   * @private
   */
   _buildWhereClause(filters = {}) {
    const { search, status, role } = filters;
    const where = {};

    // 多字段模糊搜索
    if (search) {
      where[Op.or] = [
        { username: { [Op.like]: `%${search}%` } },
        { email: { [Op.like]: `%${search}%` } },
        { nickname: { [Op.like]: `%${search}%` } },
      ];
    }

    // 精确匹配字段
    if (status) where.status = status;
    if (role) where.role = role;

    return where;
  }
  /**
   * 获取用户公开信息（不包含敏感字段）
   * @param userId 目标用户ID
   */
   async getPublicProfile(userId) {
    const user = await this._getUser(userId, this.PUBLIC_FIELDS);
    if (!user) throw new NotFoundError("用户不存在");
    return user;
  }

  /**
   * 根据ID获取用户完整信息（需管理员权限）
   * @param userId 目标用户ID
   * @param isAdmin 是否管理员权限
   */
   async getUserById(userId, isAdmin) {
    const attributes = isAdmin ? this.ADMIN_ATTRIBUTES : this.PUBLIC_ATTRIBUTES;
    console.log("获取用户信息", userId, attributes);
    const user = await this.User.findOne({
      where: { id: userId },
      attributes,
      raw: true, // 返回纯JSON对象
    });

    if (!user) throw new NotFoundError("用户不存在");
    return user;
  }
  /**
   * 检查用户是否存在
   */
   async checkUserExists(username, email, phone) {
    const existingUser = await this.User.findOne({
      where: {
        [Op.or]: [
          // 正确的 Sequelize 语法
          { username },
          { email },
          { phone },
        ],
      },
      paranoid: false, // 包括已软删除的记录（如果需要）
    });
    return !!existingUser;
  }

  /**
   * 创建用户
   */
   async createUser(userData) {
    console.log("创建用户", userData);
    // 密码加密
    const hashedPassword = await bcrypt.hash(userData.password, 10);

    const user = new this.User({
      username: userData.username,
      password: hashedPassword,
      email: userData.email,
      phone: userData.phone,
      status: 1, // 激活状态
    });

    return await user.save();
  }
  /**
   * 更新用户信息
   */
   async updateUser(userId, userData) {
    console.log("更新用户信息", userId, userData);
    const { sequelize, User } = this.db;
    // 1. 检查输入数据
    if (!userData || Object.keys(userData).length === 0) {
      throw new BadRequestError("更新数据不能为空");
    }
    // 2. 开启事务（推荐）
    const transaction = await sequelize.transaction();

    try {
      // 3. 查找用户（加锁防止并发修改）
      const user = await this.User.findByPk(userId, {
        transaction,
        lock: transaction.LOCK.UPDATE,
      });

      if (!user) {
        throw new NotFoundError("用户不存在");
      }

      // 4. 打印更新前后对比
      console.log("更新前:", JSON.stringify(user.toJSON()));
      console.log("尝试更新:", userData);

      // 5. 执行更新
      const updatedUser = await user.update(userData, {
        transaction,
        fields: Object.keys(userData),
        validate: true, // 启用更新验证
      });

      await transaction.commit();

      console.log("更新后:", updatedUser.toJSON());
      return updatedUser;
    } catch (error) {
      await transaction.rollback();
      console.error("更新用户失败:", error);
      throw error; // 继续向上抛出错误
    }
  }

  /**
   * 批量删除用户
   * @param {Array} userIds - 要删除的用户ID数组
   * @param {boolean} force - 是否强制删除（false为软删除）
   * @returns {Promise<{deletedCount: number}>} 返回删除的用户数量
   */
  async batchDeleteUsers(userIds, force = false) {
    console.log("批量删除用户", userIds, force);

    // 1. 验证输入
    if (!Array.isArray(userIds)) {
      throw new BadRequestError("userIds 必须是一个数组");
    }
    
    if (userIds.length === 0) {
      throw new BadRequestError("userIds 不能为空");
    }

    // 2. 检查所有用户是否存在
    const existingUsers = await this.User.findAll({
      where: {
        id: {
          [Op.in]: userIds
        }
      },
      paranoid: false // 包括已软删除的记录
    });

    if (existingUsers.length !== userIds.length) {
      const foundIds = existingUsers.map(user => user.id);
      const missingIds = userIds.filter(id => !foundIds.includes(id));
      throw new NotFoundError(`以下用户不存在: ${missingIds.join(', ')}`);
    }

    // 3. 执行批量删除
    try {
      const result = await this.User.destroy({
        where: {
          id: {
            [Op.in]: userIds
          }
        },
        force: force // 是否强制删除
      });

      return {
        deletedCount: result
      };
    } catch (error) {
      console.error("批量删除用户失败:", error);
      throw new Error("批量删除用户失败");
    }
  }
  /**
   * 验证邮箱
   */
   async verifyEmail(userId, code) {
    // 实际项目中应验证邮箱验证码
    const user = await this.User.findByIdAndUpdate(
      userId,
      { $set: { emailVerified: true } },
      { new: true }
    );

    if (!user) {
      throw new HttpException(404, "用户不存在");
    }

    return user;
  }

  // 私有方法
   async _getUser(id) {
    return db.users.findUnique({ where: { id } });
  }
}

// 创建服务实例
const userService = new UserService(db);
export { userService };
